package com.pear.core.ctl;

/**
 * 类<code>ArrayTools</code>提供了数组操作快捷功能。
 *
 * @author 顾晓健
 * @version %I%, %G%
 * @since 1.0
 */
public class ArrayTools {

    /**
     * <p>交换数组中两元素。</p>
     *
     * @param ints 需要进行交换操作的数组
     * @param pos1 数组中的位置1
     * @param pos2 数组中的位置2
     * @return 交换后的数组
     */
    public static int[] swap(int[] ints, int pos1, int pos2) {
        int temp = ints[pos1];
        ints[pos1] = ints[pos2];
        ints[pos2] = temp;

        return ints;
    }

    /**
     * <p>交换数组中两元素。</p>
     *
     * @param ints 需要进行交换操作的数组
     * @param pos1 数组中的位置1
     * @param pos2 数组中的位置2
     * @return 交换后的数组
     */
    public static String[] swap(String[] ints, int pos1, int pos2) {
        String temp = ints[pos1];
        ints[pos1] = ints[pos2];
        ints[pos2] = temp;

        return ints;
    }

    /**
     * <p>交换数组中两元素。</p>
     *
     * @param ints 需要进行交换操作的数组
     * @param pos1 数组中的位置1
     * @param pos2 数组中的位置2
     * @return 交换后的数组
     */
    public static double[] swap(double[] ints, int pos1, int pos2) {
        double temp = ints[pos1];
        ints[pos1] = ints[pos2];
        ints[pos2] = temp;

        return ints;
    }

    /**
     * <p>交换数组中两元素。</p>
     *
     * @param ints 需要进行交换操作的数组
     * @param pos1 数组中的位置1
     * @param pos2 数组中的位置2
     * @return 交换后的数组
     */
    public static float[] swap(float[] ints, int pos1, int pos2) {
        float temp = ints[pos1];
        ints[pos1] = ints[pos2];
        ints[pos2] = temp;

        return ints;
    }

    /**
     * <p>交换数组中两元素。</p>
     *
     * @param ints 需要进行交换操作的数组
     * @param pos1 数组中的位置1
     * @param pos2 数组中的位置2
     * @return 交换后的数组
     */
    public static char[] swap(char[] ints, int pos1, int pos2) {
        char temp = ints[pos1];
        ints[pos1] = ints[pos2];
        ints[pos2] = temp;

        return ints;
    }

    /**
     * <p>交换数组中两元素。</p>
     *
     * @param ints 需要进行交换操作的数组
     * @param pos1 数组中的位置1
     * @param pos2 数组中的位置2
     * @return 交换后的数组
     */
    public static byte[] swap(byte[] ints, int pos1, int pos2) {
        byte temp = ints[pos1];
        ints[pos1] = ints[pos2];
        ints[pos2] = temp;

        return ints;
    }

    /**
     * <p>反转数组。</p>
     *
     * @param source 需要进行反转操作的数组
     * @return 反转后的数组
     */
    public static int[] reverse(int[] source) {
        int length = source.length;
        int temp = 0;

        for (int i = 0; i < length / 2; i++) {
            temp = source[i];
            source[i] = source[length - 1 - i];
            source[length - 1 - i] = temp;
        }

        return source;
    }


    /**
     * <p>字符数组转换为长整形数组。</p>
     *
     * @param arr 字符数组，若为Null将返回Null
     * @return 长整形数组
     */
    public static long[] stringToLong(String[] arr) {
        if (arr == null) {
            return null;
        }

        long[] temp = new long[0];

        try {
            temp = new long[arr.length];
            for (int i = 0; i < arr.length; i++) {
                temp[i] = Long.parseLong(arr[i]);
            }
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Input string not a number.");
        }

        return temp;
    }

    /**
     * <p>长整形数组转换为字符数组。</p>
     *
     * @param arr 长整形数组，若为Null将返回Null
     * @return 字符数组
     */
    public static String[] longToString(long[] arr) {
        if (arr == null) {
            return null;
        }

        String[] temp = new String[arr.length];
        for (int i = 0; i < arr.length; i++) {
            temp[i] = String.valueOf(arr[i]);
        }

        return temp;
    }

    /**
     * <p>字符数组转换为整形数组。</p>
     *
     * @param arr 字符数组，若为Null将返回Null
     * @return 整形数组
     */
    public static int[] stringToInt(String[] arr) {
        if (arr == null) {
            return null;
        }

        int[] temp = new int[0];
        try {
            temp = new int[arr.length];
            for (int i = 0; i < arr.length; i++) {
                temp[i] = Integer.parseInt(arr[i]);
            }
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Input string not a number.");
        }

        return temp;
    }

    /**
     * <p>整形数组转换为字符数组。</p>
     *
     * @param arr 长整形数组，若为Null将返回Null
     * @return 字符数组
     */
    public static String[] intToString(int[] arr) {
        if (arr == null) {
            return null;
        }

        String[] temp = new String[arr.length];
        for (int i = 0; i < arr.length; i++) {
            temp[i] = String.valueOf(arr[i]);
        }

        return temp;
    }

    /**
     * <p>判断数组中是否包含指定的长整数。</p>
     *
     * @param array 待判断数组
     * @param value 指定长整数
     * @return 若包含指定长整数，则返回{@code true}；否则返回{@code false}
     */
    public static boolean isContain(long[] array, long value) {
        if (array == null) {
            return false;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] == value) {
                return true;
            }
        }

        return false;
    }

    /**
     * <p>判断数组中是否包含指定的字符串。</p>
     *
     * @param array 待判断数组
     * @param str   指定字符串
     * @return 若包含指定字符串，则返回{@code true}；否则返回{@code false}
     */
    public static boolean isContain(String[] array, String str) {
        if (array == null) {
            return false;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i].equals(str)) {
                return true;
            }
        }

        return false;
    }

    /**
     * <p>判断数组中是否包含指定的双精度数。</p>
     *
     * @param array 待判断数组
     * @param d     指定双精度数
     * @return 若包含指定双精度数，则返回{@code true}；否则返回{@code false}
     */
    public static boolean isContain(double[] array, double d) {
        if (array == null) {
            return false;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] == d) {
                return true;
            }
        }

        return false;
    }

    /**
     * <p>判断数组中是否包含指定的浮点数。</p>
     *
     * @param array 待判断数组
     * @param f     指定浮点数
     * @return 若包含指定浮点数，则返回{@code true}；否则返回{@code false}
     */
    public static boolean isContain(float[] array, float f) {
        if (array == null) {
            return false;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] == f) {
                return true;
            }
        }

        return false;
    }

    /**
     * <p>判断数组中是否包含指定的字符。</p>
     *
     * @param array 待判断数组
     * @param c     指定字符
     * @return 若包含指定字符，则返回{@code true}；否则返回{@code false}
     */
    public static boolean isContain(char[] array, char c) {
        if (array == null) {
            return false;
        }

        for (int i = 0; i < array.length; i++) {
            if (array[i] == c) {
                return true;
            }
        }

        return false;
    }

    /**
     * <p>将字符参数填充到字符数组中。</p>
     *
     * @param strs 参数，若为Null将返回Null
     * @return 填充数据的数组
     */
    public static String[] fillArray(String... strs) {
        if (strs == null) {
            return null;
        }

        String[] str = new String[strs.length];
        for (int i = 0; i < strs.length; i++) {
            str[i] = strs[i];
        }

        return str;
    }

    /**
     * <p>将长整数参数填充到长整数组中。</p>
     *
     * @param longs 参数，若为Null将返回Null
     * @return 填充数据的数组
     */
    public static long[] fillArray(long... longs) {
        if (longs == null) {
            return null;
        }

        long[] ll = new long[longs.length];
        for (int i = 0; i < longs.length; i++) {
            ll[i] = longs[i];
        }

        return ll;
    }

    /**
     * <p>将浮点数参数填充到长整数组中。</p>
     *
     * @param floats 参数，若为Null将返回Null
     * @return 填充数据的数组
     */
    public static float[] fillArray(float... floats) {
        if (floats == null) {
            return null;
        }

        float[] ff = new float[floats.length];
        for (int i = 0; i < floats.length; i++) {
            ff[i] = floats[i];
        }

        return ff;
    }

    /**
     * <p>将双精度数参数填充到长整数组中。</p>
     *
     * @param doubles 参数，若为Null将返回Null
     * @return 填充数据的数组
     */
    public static double[] fillArray(double... doubles) {
        if (doubles == null) {
            return null;
        }

        double[] dd = new double[doubles.length];
        for (int i = 0; i < doubles.length; i++) {
            dd[i] = doubles[i];
        }

        return dd;
    }

    /**
     * <p>将字符参数填充到长整数组中。</p>
     *
     * @param chars 参数，若为Null将返回Null
     * @return 填充数据的数组
     */
    public static char[] fillArray(char... chars) {
        if (chars == null) {
            return null;
        }

        char[] cc = new char[chars.length];
        for (int i = 0; i < chars.length; i++) {
            cc[i] = chars[i];
        }

        return cc;
    }

    /**
     * <p>将字节参数填充到长整数组中。</p>
     *
     * @param bytes 参数，若为Null将返回Null
     * @return 填充数据的数组
     */
    public static byte[] fillArray(byte... bytes) {
        if (bytes == null) {
            return null;
        }

        byte[] bb = new byte[bytes.length];
        for (int i = 0; i < bytes.length; i++) {
            bb[i] = bytes[i];
        }

        return bb;
    }

}
